/**
 * c14_char_basics - 字符类型：Unicode字符的存储
 * 
 * 这是《Rust基础数据类型实战Cookbook》系列的第14个案例
 * 
 * 学习目标：
 * 1. 理解 Rust 中 char 类型的基本概念和 Unicode 支持
 * 2. 掌握字符字面量的各种写法和转义序列
 * 3. 了解 Unicode 标量值的概念和表示范围
 * 4. 学习字符的内存存储方式（4字节 UTF-32）
 * 5. 掌握字符的判断方法和属性检查
 * 6. 学习字符的转换操作（大小写、数值等）
 * 7. 理解字符与字符串、字节的区别和转换
 * 
 * 主要内容：
 * - char 类型的特性和 4 字节存储原理
 * - Unicode 标量值和编码范围
 * - 字符字面量：基本字符、转义字符、Unicode 转义
 * - ASCII、多字节字符、表情符号的处理
 * - 字符分类判断：字母、数字、空白、标点等
 * - 字符转换：大小写转换、数值转换等
 * - 字符与字符串、字节数组的相互转换
 * - 实际应用：文本处理、国际化、输入验证
 */

fn main() {
    println!("=== Rust 字符类型基础示例 ===\n");

    // 1. char 类型概述
    demonstrate_char_basics();
    
    // 2. 字符字面量语法
    demonstrate_char_literals();
    
    // 3. Unicode 编码和范围
    demonstrate_unicode_support();
    
    // 4. 字符判断方法
    demonstrate_char_classification();
    
    // 5. 字符转换操作
    demonstrate_char_conversion();
    
    // 6. 字符与其他类型的转换
    demonstrate_char_type_conversion();
    
    // 7. 实际应用场景
    demonstrate_practical_applications();
    
    println!("\n=== 总结 ===");
    println!("Rust 的 char 类型具有以下优势：");
    println!("- 完整的 Unicode 支持，可存储任意合法字符");
    println!("- 4 字节固定长度，简化内存管理");
    println!("- 丰富的字符判断和转换方法");
    println!("- 与字符串和字节的安全转换机制");
    println!("这使得 Rust 非常适合处理国际化和多语言文本。");
}

/**
 * 演示 char 类型的基本概念
 * 
 * 重点知识：
 * - char 类型占用 4 字节（32位）
 * - 存储 Unicode 标量值
 * - 支持从 U+0000 到 U+D7FF 和 U+E000 到 U+10FFFF 的范围
 * - 不包括代理对（surrogate pairs）
 */
fn demonstrate_char_basics() {
    println!("1. char 类型概述");
    println!("   Rust 的 char 类型是 4 字节的 Unicode 标量值");
    
    // 1.1 基本概念
    println!("\n1.1 基本概念");
    
    let ascii_char: char = 'A';
    let chinese_char: char = '中';
    let emoji_char: char = '😀';
    
    println!("char 类型示例：");
    println!("  ASCII 字符: '{}' ", ascii_char);
    println!("  中文字符: '{}' ", chinese_char);
    println!("  表情符号: '{}' ", emoji_char);
    
    // 内存占用
    println!("\n内存占用：");
    println!("  char 类型大小: {} 字节", std::mem::size_of::<char>());
    println!("  所有字符都占用相同的内存空间");
    
    // 1.2 Unicode 标量值
    println!("\n1.2 Unicode 标量值");
    
    // 获取字符的 Unicode 码点
    println!("Unicode 码点：");
    println!("  '{}' = U+{:04X} = {}", ascii_char, ascii_char as u32, ascii_char as u32);
    println!("  '{}' = U+{:04X} = {}", chinese_char, chinese_char as u32, chinese_char as u32);
    println!("  '{}' = U+{:04X} = {}", emoji_char, emoji_char as u32, emoji_char as u32);
    
    // 从 Unicode 码点创建字符
    let char_from_code = char::from_u32(65).unwrap();  // 'A' 的码点
    let char_from_code_cn = char::from_u32(20013).unwrap();  // '中' 的码点
    
    println!("从码点创建字符：");
    println!("  U+0041 → '{}'", char_from_code);
    println!("  U+4E2D → '{}'", char_from_code_cn);
    
    // 1.3 有效范围
    println!("\n1.3 Unicode 标量值的有效范围");
    
    println!("有效的 Unicode 标量值范围：");
    println!("  U+0000 到 U+D7FF (0 到 55,295)");
    println!("  U+E000 到 U+10FFFF (57,344 到 1,114,111)");
    println!("  排除代理对范围：U+D800 到 U+DFFF");
    
    // 测试无效的码点
    println!("无效码点测试：");
    println!("  U+D800 (代理对): {:?}", char::from_u32(0xD800));
    println!("  U+110000 (超出范围): {:?}", char::from_u32(0x110000));
    
    // 边界值测试
    println!("边界值：");
    println!("  最小值 U+0000: {:?}", char::from_u32(0));
    println!("  最大值 U+10FFFF: {:?}", char::from_u32(0x10FFFF));
    
    // 1.4 与其他语言的对比
    println!("\n1.4 与其他语言的对比");
    
    println!("Rust char vs 其他语言：");
    println!("  C/C++: char 通常是 1 字节，只支持 ASCII");
    println!("  Java: char 是 2 字节，使用 UTF-16，有代理对问题");
    println!("  Python: 字符串是 Unicode，但没有单独的字符类型");
    println!("  Rust: char 是 4 字节，直接存储 Unicode 标量值，无代理对问题");
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示字符字面量的各种写法
 * 
 * 重点知识：
 * - 基本字符字面量用单引号
 * - 转义序列的使用
 * - Unicode 转义的多种形式
 * - 特殊字符的表示方法
 */
fn demonstrate_char_literals() {
    println!("\n2. 字符字面量语法");
    println!("   掌握各种字符字面量的写法");
    
    // 2.1 基本字符字面量
    println!("\n2.1 基本字符字面量");
    
    // 普通字符
    let letter = 'a';
    let digit = '5';
    let symbol = '@';
    let space = ' ';
    
    println!("基本字符：");
    println!("  字母: '{}'", letter);
    println!("  数字: '{}'", digit);
    println!("  符号: '{}'", symbol);
    println!("  空格: '{}'", space);
    
    // 2.2 转义字符
    println!("\n2.2 转义字符");
    
    // 常见转义字符
    let newline = '\n';          // 换行符
    let tab = '\t';              // 制表符
    let carriage_return = '\r';  // 回车符
    let backslash = '\\';        // 反斜杠
    let single_quote = '\'';     // 单引号
    let null_char = '\0';        // 空字符
    
    println!("转义字符：");
    println!("  换行符: '\\n' = ASCII {}", newline as u32);
    println!("  制表符: '\\t' = ASCII {}", tab as u32);
    println!("  回车符: '\\r' = ASCII {}", carriage_return as u32);
    println!("  反斜杠: '\\\\' = ASCII {}", backslash as u32);
    println!("  单引号: '\\'' = ASCII {}", single_quote as u32);
    println!("  空字符: '\\0' = ASCII {}", null_char as u32);
    
    // 2.3 Unicode 转义
    println!("\n2.3 Unicode 转义");
    
    // ASCII 转义 \\x
    let ascii_a = '\x41';        // 'A' 的十六进制表示
    let ascii_newline = '\x0A';  // 换行符的十六进制表示
    
    println!("ASCII 十六进制转义 (\\x)：");
    println!("  '\\x41' = '{}'", ascii_a);
    println!("  '\\x0A' = 换行符 (ASCII {})", ascii_newline as u32);
    
    // Unicode 4位转义 \\u{}
    let unicode_heart = '\u{2764}';     // ❤️ 心形符号
    let unicode_chinese = '\u{4E2D}';   // 中文字符 "中"
    let unicode_face = '\u{1F60A}';     // 😊 笑脸表情
    
    println!("Unicode 转义 (\\u{{}})：");
    println!("  '\\u{{2764}}' = '{}' (心形)", unicode_heart);
    println!("  '\\u{{4E2D}}' = '{}' (中文)", unicode_chinese);
    println!("  '\\u{{1F60A}}' = '{}' (表情)", unicode_face);
    
    // 2.4 各种语言的字符
    println!("\n2.4 多语言字符示例");
    
    // 拉丁字母
    let latin_chars = ['A', 'B', 'C', 'a', 'b', 'c'];
    println!("拉丁字母: {:?}", latin_chars);
    
    // 中文字符
    let chinese_chars = ['中', '国', '你', '好'];
    println!("中文字符: {:?}", chinese_chars);
    
    // 日文字符
    let japanese_chars = ['あ', 'か', 'さ', 'た', 'な'];  // 平假名
    println!("日文平假名: {:?}", japanese_chars);
    
    let katakana_chars = ['ア', 'カ', 'サ', 'タ', 'ナ'];  // 片假名
    println!("日文片假名: {:?}", katakana_chars);
    
    // 韩文字符
    let korean_chars = ['한', '국', '어'];
    println!("韩文字符: {:?}", korean_chars);
    
    // 阿拉伯字符
    let arabic_chars = ['ا', 'ب', 'ت', 'ث'];
    println!("阿拉伯字符: {:?}", arabic_chars);
    
    // 希腊字母
    let greek_chars = ['α', 'β', 'γ', 'δ', 'π', 'Σ'];
    println!("希腊字母: {:?}", greek_chars);
    
    // 2.5 特殊符号和表情
    println!("\n2.5 特殊符号和表情");
    
    // 数学符号
    let math_symbols = ['±', '×', '÷', '∞', '∑', '∫', '√', '≠', '≤', '≥'];
    println!("数学符号: {:?}", math_symbols);
    
    // 货币符号
    let currency_symbols = ['$', '€', '¥', '£', '₹', '₽', '₩'];
    println!("货币符号: {:?}", currency_symbols);
    
    // 表情符号
    let emoji_faces = ['😀', '😂', '😍', '🤔', '😢', '😡', '🙄', '😴'];
    println!("表情符号: {:?}", emoji_faces);
    
    // 其他表情
    let emoji_objects = ['🎉', '🎂', '🎁', '⚽', '🚗', '✈', '🏠', '📱'];
    println!("物体表情: {:?}", emoji_objects);
    
    // 2.6 控制字符
    println!("\n2.6 控制字符");
    
    println!("常见控制字符及其 ASCII 码：");
    let control_chars = [
        ('\0', "空字符 (NUL)"),
        ('\x07', "响铃 (BEL)"),
        ('\x08', "退格 (BS)"),
        ('\t', "水平制表 (HT)"),
        ('\n', "换行 (LF)"),
        ('\x0B', "垂直制表 (VT)"),
        ('\x0C', "换页 (FF)"),
        ('\r', "回车 (CR)"),
        ('\x1B', "转义 (ESC)"),
    ];
    
    for (ch, desc) in control_chars {
        println!("  ASCII {:3}: {} - {}", ch as u32, desc, 
                if ch.is_control() { "控制字符" } else { "非控制字符" });
    }
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示 Unicode 支持和编码
 * 
 * 重点知识：
 * - Unicode 的分类和平面
 * - 不同字符集的支持
 * - 字符的编码长度
 * - Emoji 和复杂字符处理
 */
fn demonstrate_unicode_support() {
    println!("\n3. Unicode 编码和范围");
    println!("   了解 Rust 对 Unicode 的全面支持");
    
    // 3.1 Unicode 平面
    println!("\n3.1 Unicode 平面 (Planes)");
    
    println!("Unicode 组织结构：");
    println!("  基本多文种平面 (BMP): U+0000 到 U+FFFF");
    println!("  增补平面: U+10000 到 U+10FFFF");
    println!("  总共 17 个平面，每个平面 65,536 个码点");
    
    // BMP 平面示例
    let bmp_chars = [
        ('A', "基本拉丁"),
        ('中', "中日韩表意文字"),
        ('α', "希腊字母"),
        ('⚡', "杂项符号"),
        ('♠', "杂项符号"),
    ];
    
    println!("\n基本多文种平面 (BMP) 示例：");
    for (ch, desc) in bmp_chars {
        println!("  '{}' = U+{:04X} ({})", ch, ch as u32, desc);
    }
    
    // 增补平面示例
    let supplementary_chars = [
        ('𝓐', "数学字母数字符号"),
        ('𝟎', "数学字母数字符号"),
        ('🌟', "杂项符号和象形文字"),
        ('🚀', "交通和地图符号"),
        ('👨', "杂项符号和象形文字"),
    ];
    
    println!("增补平面示例：");
    for (ch, desc) in supplementary_chars {
        println!("  '{}' = U+{:04X} ({})", ch, ch as u32, desc);
    }
    
    // 3.2 字符分类
    println!("\n3.2 Unicode 字符分类");
    
    // 按脚本分类
    let scripts = [
        ('A', "Latin 拉丁"),
        ('中', "Han 汉字"),
        ('あ', "Hiragana 平假名"),
        ('カ', "Katakana 片假名"),
        ('한', "Hangul 韩文"),
        ('ا', "Arabic 阿拉伯"),
        ('Α', "Greek 希腊"),
        ('А', "Cyrillic 西里尔"),
        ('ა', "Georgian 格鲁吉亚"),
        ('अ', "Devanagari 天城文"),
    ];
    
    println!("世界主要文字系统：");
    for (ch, desc) in scripts {
        println!("  '{}' = U+{:04X} ({})", ch, ch as u32, desc);
    }
    
    // 3.3 Emoji 和复杂字符
    println!("\n3.3 Emoji 和复杂字符");
    
    // 基本 Emoji
    let basic_emoji = ['😀', '😂', '❤', '👍', '🔥', '💯', '🎉', '🚀'];
    println!("基本 Emoji：");
    for emoji in basic_emoji {
        println!("  '{}' = U+{:04X}", emoji, emoji as u32);
    }
    
    // 修饰符 Emoji（注意：这些在字符串中可能显示不正确，因为需要组合）
    println!("Emoji 修饰符：");
    let skin_tone_base = '👋';  // 挥手基础
    println!("  基础 Emoji: '{}' = U+{:04X}", skin_tone_base, skin_tone_base as u32);
    
    // 修饰符码点（这些单独不可见）
    let modifier_light = '\u{1F3FB}';  // 浅肤色修饰符
    let modifier_dark = '\u{1F3FF}';   // 深肤色修饰符
    println!("  浅肤色修饰符: U+{:04X}", modifier_light as u32);
    println!("  深肤色修饰符: U+{:04X}", modifier_dark as u32);
    
    // 3.4 字符编码长度
    println!("\n3.4 不同编码下的字节长度");
    
    let test_chars = [
        ('A', "ASCII"),
        ('中', "中文"),
        ('😀', "Emoji"),
        ('𝓐', "数学符号"),
    ];
    
    println!("字符在不同编码下的字节长度：");
    println!("字符 | Unicode  | UTF-8  | UTF-16 | UTF-32");
    println!("-----|----------|--------|---------|---------");
    
    for (ch, desc) in test_chars {
        let utf8_len = ch.to_string().len();  // UTF-8 字节长度
        let utf16_len = ch.to_string().encode_utf16().count() * 2; // UTF-16 字节长度
        
        println!("{:<4} | U+{:04X}   | {:<6} | {:<7} | 4       ({})",
                ch, ch as u32, 
                format!("{} 字节", utf8_len),
                format!("{} 字节", utf16_len),
                desc);
    }
    
    // 3.5 字符范围检查
    println!("\n3.5 字符范围检查");
    
    fn analyze_char_range(ch: char) -> String {
        let code = ch as u32;
        match code {
            0x0000..=0x007F => "ASCII (基本拉丁)".to_string(),
            0x0080..=0x00FF => "Latin-1 补充".to_string(),
            0x0100..=0x017F => "拉丁文扩展-A".to_string(),
            0x0180..=0x024F => "拉丁文扩展-B".to_string(),
            0x1E00..=0x1EFF => "拉丁文扩展附加".to_string(),
            0x0370..=0x03FF => "希腊文和科普特文".to_string(),
            0x0400..=0x04FF => "西里尔文".to_string(),
            0x4E00..=0x9FFF => "中日韩统一表意文字".to_string(),
            0x3040..=0x309F => "平假名".to_string(),
            0x30A0..=0x30FF => "片假名".to_string(),
            0xAC00..=0xD7AF => "韩文音节".to_string(),
            0x1F600..=0x1F64F => "表情符号".to_string(),
            0x1F680..=0x1F6FF => "交通和地图符号".to_string(),
            0x1F900..=0x1F9FF => "增补符号和象形文字".to_string(),
            _ => format!("其他 Unicode 区块 (U+{:04X})", code),
        }
    }
    
    let range_test_chars = ['A', 'Ω', 'Я', '中', 'あ', 'カ', '한', '😀', '🚀'];
    
    println!("字符范围分析：");
    for ch in range_test_chars {
        println!("  '{}' = U+{:04X} → {}", ch, ch as u32, analyze_char_range(ch));
    }
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示字符分类判断
 * 
 * 重点知识：
 * - 字母判断方法
 * - 数字判断方法
 * - 空白字符判断
 * - 控制字符和标点符号
 */
fn demonstrate_char_classification() {
    println!("\n4. 字符判断方法");
    println!("   掌握各种字符分类和属性检查");
    
    // 4.1 基本分类判断
    println!("\n4.1 基本字符分类");
    
    let test_chars = [
        'A', 'a', '5', ' ', '\n', '\t', '中', 'α', 
        '!', '@', '#', '$', '%', '😀', '™', '©'
    ];
    
    println!("字符分类测试：");
    println!("字符 | 字母 | 数字 | 字母数字 | 空白 | 控制 | ASCII");
    println!("-----|------|------|----------|------|------|-------");
    
    for ch in test_chars {
        println!("{:<4} | {:<4} | {:<4} | {:<8} | {:<4} | {:<4} | {}",
                ch,
                if ch.is_alphabetic() { "是" } else { "否" },
                if ch.is_numeric() { "是" } else { "否" },
                if ch.is_alphanumeric() { "是" } else { "否" },
                if ch.is_whitespace() { "是" } else { "否" },
                if ch.is_control() { "是" } else { "否" },
                if ch.is_ascii() { "是" } else { "否" });
    }
    
    // 4.2 详细分类方法
    println!("\n4.2 详细字符分类方法");
    
    // 字母类型
    println!("字母类型判断：");
    let letter_tests = ['A', 'a', 'Z', 'z', '中', 'α', 'Ω', '😀'];
    
    for ch in letter_tests {
        let mut types = Vec::new();
        
        if ch.is_alphabetic() { types.push("字母"); }
        if ch.is_uppercase() { types.push("大写"); }
        if ch.is_lowercase() { types.push("小写"); }
        if ch.is_ascii_alphabetic() { types.push("ASCII字母"); }
        if ch.is_ascii_uppercase() { types.push("ASCII大写"); }
        if ch.is_ascii_lowercase() { types.push("ASCII小写"); }
        
        println!("  '{}': {}", ch, 
                if types.is_empty() { "非字母".to_string() } 
                else { types.join(", ") });
    }
    
    // 数字类型
    println!("\n数字类型判断：");
    let digit_tests = ['0', '9', '５', '①', '⑴', 'Ⅰ', 'ⅰ', '半', 'A'];
    
    for ch in digit_tests {
        let mut types = Vec::new();
        
        if ch.is_numeric() { types.push("数字".to_string()); }
        if ch.is_ascii_digit() { types.push("ASCII数字".to_string()); }
        
        // 尝试转换为数字值
        if let Some(digit_value) = ch.to_digit(10) {
            types.push(format!("十进制值:{}", digit_value));
        }
        if let Some(digit_value) = ch.to_digit(16) {
            types.push(format!("十六进制值:{}", digit_value));
        }
        
        println!("  '{}': {}", ch, 
                if types.is_empty() { "非数字".to_string() } 
                else { types.join(", ") });
    }
    
    // 4.3 空白字符
    println!("\n4.3 空白字符判断");
    
    let whitespace_chars = [
        ' ',      // 普通空格
        '\t',     // 制表符
        '\n',     // 换行符
        '\r',     // 回车符
        '\u{00A0}', // 非断行空格
        '\u{2000}', // EN QUAD
        '\u{2028}', // 行分隔符
        '\u{2029}', // 段落分隔符
        'A',      // 非空白字符
    ];
    
    println!("空白字符测试：");
    for ch in whitespace_chars {
        let name = match ch {
            ' ' => "普通空格",
            '\t' => "制表符",
            '\n' => "换行符",
            '\r' => "回车符",
            '\u{00A0}' => "非断行空格",
            '\u{2000}' => "EN QUAD",
            '\u{2028}' => "行分隔符",
            '\u{2029}' => "段落分隔符",
            _ => "普通字符",
        };
        
        println!("  U+{:04X} ({}): {} {}",
                ch as u32, name,
                if ch.is_whitespace() { "是空白" } else { "非空白" },
                if ch.is_ascii_whitespace() { "(ASCII空白)" } else { "" });
    }
    
    // 4.4 标点符号
    println!("\n4.4 标点符号判断");
    
    let punctuation_chars = [
        '.', ',', '!', '?', ';', ':', '"', '\'',
        '(', ')', '[', ']', '{', '}',
        '，', '。', '！', '？', '；', '：', '"', '"',
        '《', '》', '（', '）', '【', '】',
    ];
    
    println!("标点符号测试：");
    for ch in punctuation_chars {
        println!("  '{}': U+{:04X} {}",
                ch, ch as u32,
                if ch.is_ascii_punctuation() { "ASCII标点" } else { "Unicode标点" });
    }
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示字符转换操作
 * 
 * 重点知识：
 * - 大小写转换
 * - 数字字符转换为数值
 * - 字符的各种变换操作
 * - 转换的安全性和适用范围
 */
fn demonstrate_char_conversion() {
    println!("\n5. 字符转换操作");
    println!("   掌握各种字符转换和变换方法");
    
    // 5.1 大小写转换
    println!("\n5.1 大小写转换");
    
    let test_letters = ['A', 'a', 'Z', 'z', '中', 'α', 'Ω', 'ß', 'İ'];
    
    println!("大小写转换测试：");
    println!("原字符 | 转大写 | 转小写 | ASCII大写 | ASCII小写");
    println!("-------|--------|--------|-----------|-----------");
    
    for ch in test_letters {
        let uppercase: String = ch.to_uppercase().collect();
        let lowercase: String = ch.to_lowercase().collect();
        let ascii_upper = if ch.is_ascii() { ch.to_ascii_uppercase() } else { ch };
        let ascii_lower = if ch.is_ascii() { ch.to_ascii_lowercase() } else { ch };
        
        println!("{:<6} | {:<6} | {:<6} | {:<9} | {}",
                ch, uppercase, lowercase, ascii_upper, ascii_lower);
    }
    
    // 特殊大小写转换案例
    println!("\n特殊大小写转换案例：");
    
    // 德语的 ß (Eszett)
    let eszett = 'ß';
    let eszett_upper: String = eszett.to_uppercase().collect();
    println!("德语 ß → 大写: {} (转换为 SS)", eszett_upper);
    
    // 土耳其语的特殊 i
    let turkish_i = 'i';
    let turkish_I = 'I';
    println!("土耳其语 i 转换:");
    println!("  'i' → 大写: {}", turkish_i.to_uppercase().collect::<String>());
    println!("  'I' → 小写: {}", turkish_I.to_lowercase().collect::<String>());
    
    // 5.2 数字字符转换
    println!("\n5.2 数字字符转换");
    
    let digit_chars = ['0', '1', '9', 'A', 'F', 'a', 'f', 'G', 'Z'];
    
    println!("数字字符转换测试：");
    println!("字符 | 十进制 | 十六进制 | 三十六进制 | 是否有效");
    println!("-----|--------|----------|------------|----------");
    
    for ch in digit_chars {
        let decimal = ch.to_digit(10);
        let hexadecimal = ch.to_digit(16);
        let base36 = ch.to_digit(36);
        
        println!("{:<4} | {:<6} | {:<8} | {:<10} | {}",
                ch,
                decimal.map_or("无效".to_string(), |d| d.to_string()),
                hexadecimal.map_or("无效".to_string(), |d| d.to_string()),
                base36.map_or("无效".to_string(), |d| d.to_string()),
                if ch.is_ascii_alphanumeric() { "字母数字" } else { "其他" });
    }
    
    // 5.3 数值转字符
    println!("\n5.3 数值转字符");
    
    println!("数值转字符测试：");
    for radix in [2, 8, 10, 16, 36] {
        println!("{}进制数字字符:", radix);
        for digit in 0..radix.min(10) {
            if let Some(ch) = std::char::from_digit(digit, radix) {
                println!("  {} → '{}'", digit, ch);
            }
        }
        if radix > 10 {
            println!("  字母部分:");
            for digit in 10..radix.min(16) {
                if let Some(ch) = std::char::from_digit(digit, radix) {
                    println!("  {} → '{}'", digit, ch);
                }
            }
        }
    }
    
    // 5.4 其他转换操作
    println!("\n5.4 其他字符转换");
    
    // 转义字符展示
    let escape_chars = ['\n', '\t', '\r', '\\', '\'', '"', '\0'];
    println!("转义字符展示：");
    for ch in escape_chars {
        println!("  '{}' = U+{:04X} = ASCII {} ({})",
                ch.escape_default().collect::<String>(),
                ch as u32,
                ch as u32,
                match ch {
                    '\n' => "换行",
                    '\t' => "制表",
                    '\r' => "回车",
                    '\\' => "反斜杠",
                    '\'' => "单引号",
                    '"' => "双引号",
                    '\0' => "空字符",
                    _ => "其他",
                });
    }
    
    // 字符迭代器和转换
    println!("\n字符的 escape 方法：");
    let special_chars = ['中', '🚀', '\n', '"'];
    for ch in special_chars {
        println!("  '{}': default={}, debug={}, unicode={}",
                ch,
                ch.escape_default().collect::<String>(),
                ch.escape_debug().collect::<String>(),
                ch.escape_unicode().collect::<String>());
    }
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示字符与其他类型的转换
 * 
 * 重点知识：
 * - 字符与整数的相互转换
 * - 字符与字符串的转换
 * - 字符与字节的关系
 * - UTF-8编码相关转换
 */
fn demonstrate_char_type_conversion() {
    println!("\n6. 字符与其他类型的转换");
    println!("   掌握字符与数值、字符串、字节之间的转换");
    
    // 6.1 字符与整数转换
    println!("\n6.1 字符与整数转换");
    
    let chars_to_convert = ['A', '0', '中', '🚀', '\n'];
    
    println!("字符转整数：");
    for ch in chars_to_convert {
        println!("  '{}' → u32: {} (U+{:04X})", 
                ch, ch as u32, ch as u32);
    }
    
    println!("整数转字符：");
    let codes = [65, 48, 20013, 128640, 10];
    for code in codes {
        match char::from_u32(code) {
            Some(ch) => println!("  {} (U+{:04X}) → '{}'", code, code, ch),
            None => println!("  {} → 无效的 Unicode 码点", code),
        }
    }
    
    // 边界情况测试
    println!("\n边界情况测试：");
    let boundary_codes = [0, 0xD7FF, 0xD800, 0xDFFF, 0xE000, 0x10FFFF, 0x110000];
    for code in boundary_codes {
        match char::from_u32(code) {
            Some(ch) => println!("  U+{:04X} → '{}' ✓", code, 
                               if ch.is_control() { 
                                   format!("控制字符({:?})", ch.escape_unicode().collect::<String>()) 
                               } else { 
                                   ch.to_string() 
                               }),
            None => println!("  U+{:04X} → 无效 ✗", code),
        }
    }
    
    // 6.2 字符与字符串转换
    println!("\n6.2 字符与字符串转换");
    
    // 字符转字符串
    println!("字符转字符串：");
    for ch in chars_to_convert {
        let string1 = ch.to_string();           // 使用 to_string()
        let string2 = format!("{}", ch);        // 使用 format!
        let string3: String = [ch].iter().collect();  // 使用迭代器
        
        println!("  '{}' → \"{}\" (长度: {} 字节)", ch, string1, string1.len());
        assert_eq!(string1, string2);
        assert_eq!(string1, string3);
    }
    
    // 字符串转字符（获取第一个字符）
    println!("\n字符串转字符（首字符）：");
    let strings = ["A", "中国", "🚀rocket", "hello", ""];
    for s in strings {
        match s.chars().next() {
            Some(ch) => println!("  \"{}\" → 首字符: '{}'", s, ch),
            None => println!("  \"{}\" → 空字符串", s),
        }
    }
    
    // 6.3 字符与 UTF-8 字节转换
    println!("\n6.3 字符与 UTF-8 字节转换");
    
    println!("字符的 UTF-8 编码：");
    for ch in chars_to_convert {
        let mut utf8_bytes = [0; 4];  // char 最多需要 4 字节 UTF-8
        let encoded = ch.encode_utf8(&mut utf8_bytes);
        
        println!("  '{}' (U+{:04X}):", ch, ch as u32);
        println!("    UTF-8: {:?} ({} 字节)", 
                encoded.as_bytes(), encoded.len());
        println!("    二进制: {}", 
                encoded.bytes()
                    .map(|b| format!("{:08b}", b))
                    .collect::<Vec<_>>()
                    .join(" "));
    }
    
    // UTF-8 解码示例
    println!("\nUTF-8 字节解码：");
    let utf8_examples = [
        vec![0x41],                    // 'A'
        vec![0xE4, 0xB8, 0xAD],       // '中'
        vec![0xF0, 0x9F, 0x9A, 0x80], // '🚀'
    ];
    
    for bytes in utf8_examples {
        match std::str::from_utf8(&bytes) {
            Ok(s) => {
                if let Some(ch) = s.chars().next() {
                    println!("  {:?} → '{}' (U+{:04X})", bytes, ch, ch as u32);
                }
            }
            Err(_) => println!("  {:?} → 无效的 UTF-8 序列", bytes),
        }
    }
    
    // 6.4 字符与 UTF-16 转换
    println!("\n6.4 字符与 UTF-16 转换");
    
    println!("字符的 UTF-16 编码：");
    for ch in chars_to_convert {
        let mut utf16_buffer = [0; 2];  // char 最多需要 2 个 UTF-16 单元
        let encoded = ch.encode_utf16(&mut utf16_buffer);
        
        println!("  '{}' (U+{:04X}):", ch, ch as u32);
        println!("    UTF-16: {:?} ({} 单元)", encoded, encoded.len());
        println!("    十六进制: {}", 
                encoded.iter()
                    .map(|u| format!("{:04X}", u))
                    .collect::<Vec<_>>()
                    .join(" "));
    }
    
    // 6.5 字符数组操作
    println!("\n6.5 字符数组和集合");
    
    // 字符数组
    let char_array = ['H', 'e', 'l', 'l', 'o', '世', '界'];
    println!("字符数组: {:?}", char_array);
    
    // 转换为字符串
    let string_from_chars: String = char_array.iter().collect();
    println!("转为字符串: \"{}\"", string_from_chars);
    
    // 字符统计
    println!("字符统计:");
    println!("  数组长度: {} 字符", char_array.len());
    println!("  字符串长度: {} 字节", string_from_chars.len());
    println!("  Unicode 字符数: {} 字符", string_from_chars.chars().count());
    
    // 字符过滤和转换
    let letters_only: String = char_array.iter()
        .filter(|ch| ch.is_alphabetic())
        .collect();
    println!("  仅字母: \"{}\"", letters_only);
    
    let uppercase: String = char_array.iter()
        .flat_map(|ch| ch.to_uppercase())
        .collect();
    println!("  全大写: \"{}\"", uppercase);
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示实际应用场景
 * 
 * 重点知识：
 * - 文本处理和分析
 * - 输入验证和清理
 * - 国际化支持
 * - 字符统计和分类
 */
fn demonstrate_practical_applications() {
    println!("\n7. 实际应用场景");
    println!("   字符类型在实际开发中的应用实例");
    
    // 7.1 文本分析和统计
    println!("\n7.1 文本分析和统计");
    
    let sample_text = "Hello World! 你好世界！🌍🚀 123 αβγ";
    
    fn analyze_text(text: &str) {
        let mut stats = std::collections::HashMap::new();
        let mut char_count = 0;
        let byte_count = text.len();
        
        // 字符分类统计
        for ch in text.chars() {
            char_count += 1;
            
            let category = if ch.is_ascii_alphabetic() {
                "ASCII字母"
            } else if ch.is_alphabetic() {
                "非ASCII字母"
            } else if ch.is_ascii_digit() {
                "ASCII数字"
            } else if ch.is_numeric() {
                "非ASCII数字"
            } else if ch.is_whitespace() {
                "空白字符"
            } else if ch.is_ascii_punctuation() {
                "ASCII标点"
            } else if ch as u32 >= 0x1F600 && ch as u32 <= 0x1F6FF {
                "表情符号"
            } else {
                "其他"
            };
            
            *stats.entry(category).or_insert(0) += 1;
        }
        
        println!("文本: \"{}\"", text);
        println!("统计结果:");
        println!("  字符总数: {}", char_count);
        println!("  字节总数: {}", byte_count);
        println!("  字符分类:");
        
        for (category, count) in stats {
            println!("    {}: {}", category, count);
        }
    }
    
    analyze_text(sample_text);
    
    // 7.2 输入验证
    println!("\n7.2 输入验证");
    
    // 用户名验证器
    fn is_valid_username(username: &str) -> (bool, String) {
        if username.is_empty() {
            return (false, "用户名不能为空".to_string());
        }
        
        if username.len() > 20 {
            return (false, "用户名长度不能超过20字符".to_string());
        }
        
        let first_char = username.chars().next().unwrap();
        if !first_char.is_alphabetic() {
            return (false, "用户名必须以字母开头".to_string());
        }
        
        for ch in username.chars() {
            if !ch.is_alphanumeric() && ch != '_' && ch != '-' {
                return (false, format!("用户名包含无效字符: '{}'", ch));
            }
        }
        
        (true, "有效用户名".to_string())
    }
    
    let usernames = ["alice", "user_123", "测试用户", "123abc", "user@name", "_test", ""];
    
    println!("用户名验证:");
    for username in usernames {
        let (valid, message) = is_valid_username(username);
        println!("  \"{}\": {} - {}", username, 
                if valid { "✓" } else { "✗" }, message);
    }
    
    // 密码强度检查
    fn check_password_strength(password: &str) -> (i32, Vec<String>) {
        let mut score = 0;
        let mut messages = Vec::new();
        
        if password.len() >= 8 {
            score += 1;
            messages.push("长度充足".to_string());
        } else {
            messages.push("长度不足".to_string());
        }
        
        let mut has_lowercase = false;
        let mut has_uppercase = false;
        let mut has_digit = false;
        let mut has_symbol = false;
        
        for ch in password.chars() {
            if ch.is_ascii_lowercase() { has_lowercase = true; }
            if ch.is_ascii_uppercase() { has_uppercase = true; }
            if ch.is_ascii_digit() { has_digit = true; }
            if ch.is_ascii_punctuation() { has_symbol = true; }
        }
        
        if has_lowercase { score += 1; messages.push("包含小写字母".to_string()); }
        if has_uppercase { score += 1; messages.push("包含大写字母".to_string()); }
        if has_digit { score += 1; messages.push("包含数字".to_string()); }
        if has_symbol { score += 1; messages.push("包含符号".to_string()); }
        
        (score, messages)
    }
    
    let passwords = ["password", "Password", "Password123", "P@ssw0rd!", "密码123"];
    
    println!("\n密码强度检查:");
    for password in passwords {
        let (score, messages) = check_password_strength(password);
        let strength = match score {
            0..=1 => "很弱",
            2..=3 => "弱",
            4 => "中等",
            5 => "强",
            _ => "很强",
        };
        
        println!("  \"{}\": 强度 {} ({}/5)", password, strength, score);
        println!("    {}", messages.join(", "));
    }
    
    // 7.3 文本清理和规范化
    println!("\n7.3 文本清理和规范化");
    
    // 去除控制字符
    fn remove_control_chars(text: &str) -> String {
        text.chars()
            .filter(|ch| !ch.is_control() || *ch == '\n' || *ch == '\t')
            .collect()
    }
    
    let messy_text = "Hello\x00World\x07!\tClean\x1Bme\n请保留这行";
    let cleaned = remove_control_chars(messy_text);
    
    println!("控制字符清理:");
    println!("  原文: {:?}", messy_text);
    println!("  清理后: {:?}", cleaned);
    
    // 文本规范化：转换全角字符
    fn normalize_width(text: &str) -> String {
        text.chars()
            .map(|ch| {
                match ch {
                    // 全角数字转半角
                    '０'..='９' => char::from_u32(ch as u32 - '０' as u32 + '0' as u32).unwrap(),
                    // 全角字母转半角
                    'Ａ'..='Ｚ' => char::from_u32(ch as u32 - 'Ａ' as u32 + 'A' as u32).unwrap(),
                    'ａ'..='ｚ' => char::from_u32(ch as u32 - 'ａ' as u32 + 'a' as u32).unwrap(),
                    // 全角空格转半角
                    '　' => ' ',
                    _ => ch,
                }
            })
            .collect()
    }
    
    let wide_text = "Ｈｅｌｌｏ　１２３　ａｂｃ";
    let normalized = normalize_width(wide_text);
    
    println!("全角转半角:");
    println!("  原文: \"{}\"", wide_text);
    println!("  转换后: \"{}\"", normalized);
    
    // 7.4 国际化文本处理
    println!("\n7.4 国际化文本处理");
    
    // 多语言字符串长度统计
    fn count_text_units(text: &str) {
        println!("文本: \"{}\"", text);
        println!("  字节数 (UTF-8): {}", text.len());
        println!("  字符数 (Unicode): {}", text.chars().count());
        println!("  UTF-16 单元数: {}", text.encode_utf16().count());
        
        // 按脚本分类
        let mut scripts = std::collections::HashMap::new();
        for ch in text.chars() {
            let script = if ch.is_ascii() {
                "ASCII"
            } else if (ch as u32) >= 0x4E00 && (ch as u32) <= 0x9FFF {
                "汉字"
            } else if (ch as u32) >= 0x3040 && (ch as u32) <= 0x309F {
                "平假名"
            } else if (ch as u32) >= 0x30A0 && (ch as u32) <= 0x30FF {
                "片假名"
            } else if (ch as u32) >= 0xAC00 && (ch as u32) <= 0xD7AF {
                "韩文"
            } else if (ch as u32) >= 0x0600 && (ch as u32) <= 0x06FF {
                "阿拉伯文"
            } else if (ch as u32) >= 0x1F600 && (ch as u32) <= 0x1F6FF {
                "表情符号"
            } else {
                "其他"
            };
            
            *scripts.entry(script).or_insert(0) += 1;
        }
        
        println!("  脚本分布:");
        for (script, count) in scripts {
            println!("    {}: {}", script, count);
        }
        println!();
    }
    
    let multilingual_texts = [
        "Hello World",
        "你好世界",
        "こんにちは世界",
        "안녕하세요 세계",
        "مرحبا بالعالم",
        "Hello 世界 🌍",
    ];
    
    for text in multilingual_texts {
        count_text_units(text);
    }
    
    // 7.5 简单的词法分析器
    println!("7.5 简单的词法分析器");
    
    #[derive(Debug, PartialEq)]
    enum TokenType {
        Letter,
        Digit,
        Operator,
        Punctuation,
        Whitespace,
        Other,
    }
    
    fn tokenize_simple(text: &str) -> Vec<(char, TokenType)> {
        text.chars()
            .map(|ch| {
                let token_type = if ch.is_alphabetic() {
                    TokenType::Letter
                } else if ch.is_numeric() {
                    TokenType::Digit
                } else if "+-*/=<>".contains(ch) {
                    TokenType::Operator
                } else if ch.is_ascii_punctuation() {
                    TokenType::Punctuation
                } else if ch.is_whitespace() {
                    TokenType::Whitespace
                } else {
                    TokenType::Other
                };
                
                (ch, token_type)
            })
            .collect()
    }
    
    let code_sample = "let x = 42 + y;";
    let tokens = tokenize_simple(code_sample);
    
    println!("词法分析示例:");
    println!("代码: \"{}\"", code_sample);
    println!("词法元素:");
    for (ch, token_type) in tokens {
        if token_type != TokenType::Whitespace {
            println!("  '{}' → {:?}", ch, token_type);
        }
    }
    
    println!("\n{}", "=".repeat(60));
}
